//------------------------------------------------------------------------------//          .
//		Instituto Tecnológico de Costa Rica       //        .  `.
//		IC-6400 Investigación de Operaciones   //      .  `.  `.
//										//    .  `.  `.  `v
//		Prof. Francisco J. Torres Rojas		      //  .  `.  `.  `v  `v
//										//.  `.  `.  `v  `v `V
//		Estudiantes:						// `.  `.  `v  `v  `V
//					Luis A. Cubillo Soto        //   `.  `v  `v  `V
//					200963696		       //       `v  `V
//					Leonel J. Murillo Retana //         `V
//					200900572		       // ____  _____ ____
// 										// |_   _| ____/  ___|
// 		III Proyecto: 						 //   |  |  |  _|   | |
// 				Transportes		        	//   |  |  | |__| |  ___
//------------------------------------------------------------------------------//   |_ | |_____\____|

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <malloc.h>
#include "Structures.h"
#include "Matrix.h"
#include "Global.h"

Stones** esquinaNoroeste(Stones** matActual, int nc, int np, int* cons, int* prod)
{
    int i = 0;
    int j = 0;
    int* consaux = cons;
    int* prodaux = prod;
    
    while((i <= np)&(j <= nc))
    {
        if(consaux[j] >= prodaux[i])
        {
            printf("%d ", i);
            printf("%d\n", j);
            printf("Es aqui\n");
            matActual[i][j].margin = prodaux[i];
            matActual[i][j].stone = 1;
            consaux[j] = consaux[j] - prodaux[i];
            prodaux[i] = 0;
            i++;
        }
        else
        {
            printf("%d ", i);
            printf("%d\n", j);
            printf("Aqui\n");
            matActual[i][j].margin = consaux[j];
            matActual[i][j].stone = 1;
            consaux[j] = prodaux[i] - consaux[j];
            consaux[j] = 0;
            j++;
        }
    }
    
    return matActual;
}

int* menorMatriz(Stones** matActual, int m, int n)
{
    int i, j;
    
    int* posMenor = (int*)malloc(sizeof(int)*3);
    int numMenor = 5;
    int contCasillas = 0;
    
    for(i = 0; i < m; i++)
    {
        for(j = 0; j< n; j++)
        {
            if((matActual[i][j].stone == 0)&&(matActual[i][j].transportation < numMenor))
            {
                printf("Aqui entre\n");
                numMenor = matActual[i][j].transportation;
                posMenor[0] = i;
                posMenor[1] = j;
                contCasillas = 0;
            }
            else
            {
                contCasillas++;
                posMenor[2] = contCasillas;
                numMenor = numMenor;
            }
        }
    }
    printf("%d\n", numMenor);
    return posMenor;
}

/*Pone -1s en la matriz*/
Stones** rellenarMat(Stones** matTrabajo, int* posInicial, int posFinal, int tipoLlenado)
{
    int i;
    //Llenar una fila
    if(tipoLlenado == 0)
    {
        for(i = posInicial[1] + 1; i<= posFinal; i++)
        {
            if(matTrabajo[posInicial[0]][i].stone == 0)
                matTrabajo[posInicial[0]][i].stone = - 1;
        }
    }
    //Llenar una columna
    else
    {
        for(i = posInicial[0]; i<= posFinal; i++)
        {
            if(matTrabajo[i][posInicial[1]].stone == 0)
                matTrabajo[i][posInicial[1]].stone = - 1;
        }
    }
    
    //Retorna la matriz
    return matTrabajo;
}

Stones** valorMinimo(Stones** matActual, int nc, int np, int* cons, int* prod)
{
    int* valsMinActual = menorMatriz(matActual, nc, np);
    
    int* prodaux = prod;
    int* consaux = cons;
    int* pIni = (int*)malloc(sizeof(int)*2);
    while(valsMinActual[2] != nc * np)
    {
        if(consaux[valsMinActual[1]] >= prodaux[valsMinActual[0]])
        {
            matActual[valsMinActual[0]][valsMinActual[1]].margin = prodaux[valsMinActual[0]];
            matActual[valsMinActual[0]][valsMinActual[1]].stone = 1;
            consaux[valsMinActual[1]] = consaux[valsMinActual[1]] - prodaux[valsMinActual[0]];
            prodaux[valsMinActual[0]] = 0;
            pIni[0] = valsMinActual[0];
            pIni[1] = valsMinActual[1];
            matActual = rellenarMat(matActual, pIni, np - 1, 0);
            valsMinActual = menorMatriz(matActual, nc, np);
        }
        else
        {
            matActual[valsMinActual[0]][valsMinActual[1]].margin = consaux[valsMinActual[1]];
            matActual[valsMinActual[0]][valsMinActual[1]].stone = 1;
            prodaux[valsMinActual[0]] = prodaux[valsMinActual[0]] - consaux[valsMinActual[1]];
            consaux[valsMinActual[1]] = 0;
            pIni[0] = valsMinActual[0];
            pIni[1] = valsMinActual[1];
            matActual = rellenarMat(matActual, pIni, nc - 1, 1);
            valsMinActual = menorMatriz(matActual, nc, np);
        }
    }
}

